package com.Lemon.Zhkuhealth.admin.controller; // 根据您的实际包名调整

import com.Lemon.Zhkuhealh.api.service.IMemberService;
import com.Lemon.Zhkuhealh.api.service.IReserveService;
import com.Lemon.Zhkuhealth.common.constant.MessageConstant;
import com.Lemon.Zhkuhealth.common.pojo.entity.Member;
import com.Lemon.Zhkuhealth.common.pojo.entity.Reserve;
import com.Lemon.Zhkuhealth.common.pojo.entity.ReserveSetting;
import com.Lemon.Zhkuhealth.common.pojo.vo.OrderTypeCountVO; // 修改为VO
import com.Lemon.Zhkuhealth.common.pojo.vo.OrderStatusCountVO; // 修改为VO
import com.Lemon.Zhkuhealth.common.pojo.vo.ReserveSubmitVo;
import com.Lemon.Zhkuhealth.common.pojo.vo.ReserveVo;
import com.Lemon.Zhkuhealth.common.util.PageResult;
import com.Lemon.Zhkuhealth.common.util.QueryPageBean;
import com.Lemon.Zhkuhealth.common.util.R; // 假设您有一个公共的 Result 包装器
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference; // 确保使用Dubbo的@DubboReference
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/reserve") // 根据您的实际需求设置基础路径
@Slf4j
public class ReserveController {

    @DubboReference // 引用Dubbo服务
    IReserveService reserveService;

    @DubboReference // 引用会员服务
    IMemberService memberService;
    /**
     * 获取预约类型分布数据，用于饼图
     * 接口路径示例: /reserve/orderType/distribution
     * @return 包含预约类型统计数据的R对象
     */
    @GetMapping("/orderType/distribution")
    public R getOrderTypePieChartData() {
        try {
            List<OrderTypeCountVO> data = reserveService.getOrderTypeDistribution(); // 返回类型改为VO
            return new R(true, MessageConstant.GET_REPORT_SUCCESS, data);
        } catch (Exception e) {
            e.printStackTrace();
            return new R(false, MessageConstant.GET_REPORT_FAIL);
        }
    }

    /**
     * 获取预约状态分布数据，用于饼图
     * 接口路径示例: /reserve/orderStatus/distribution
     * @return 包含预约状态统计数据的R对象
     */
    @GetMapping("/orderStatus/distribution")
    public R getOrderStatusPieChartData() {
        try {
            List<OrderStatusCountVO> data = reserveService.getOrderStatusDistribution();
            return new R(true, MessageConstant.GET_REPORT_SUCCESS, data);
        } catch (Exception e) {
            e.printStackTrace();
            return new R(false, MessageConstant.GET_REPORT_FAIL);
        }
    }
    /**
     * 分页查询预约列表
     * URL: /reserve/findPage
     * @param queryPageBean 查询条件 (包含 currentPage, pageSize, queryString)
     * @return 统一响应结果 (PageResult<ReserveVo>)
     */
    @PostMapping("/findPage")
    public R findPage(@RequestBody QueryPageBean queryPageBean) {
        try {
            PageResult<ReserveVo> pageResult = reserveService.findPage(queryPageBean);
            log.info("查询预约列表成功，总记录数: {}", pageResult.getTotal());
            return new R(true, MessageConstant.QUERY_ORDER_SUCCESS, pageResult);
        } catch (Exception e) {
            log.error("查询预约列表失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.QUERY_ORDER_FAIL);
        }
    }

    /**
     * 新增预约
     * URL: /reserve/add
     * @param reserve 预约实体
     * @return 统一响应结果
     */
    @PostMapping("/add")
    public R add(@RequestBody Reserve reserve) {
        try {
            // 可以在这里进行预约逻辑校验，例如可预约人数是否足够等
            reserveService.add(reserve);
            log.info("新增预约成功: {}", reserve);
            return new R(true, MessageConstant.ADD_ORDER_SUCCESS);
        } catch (Exception e) {
            log.error("新增预约失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.ADD_ORDER_FAIL);
        }
    }
    @PostMapping("/addmember") // 前端调用此接口
    public R add(@RequestBody ReserveSubmitVo reserveSubmitVo) {
        try {
            // 1. 根据手机号查询会员，判断是否为新会员
            Member member = memberService.findByPhoneNumber(reserveSubmitVo.getPhoneNumber());
            Integer memberId;

            if (member == null) {
                // 2. 如果是新会员，则自动注册
                Member newMember = new Member();
                newMember.setName(reserveSubmitVo.getName());
                newMember.setSex(reserveSubmitVo.getSex());
                newMember.setIdCard(reserveSubmitVo.getIdCard());
                newMember.setPhoneNumber(reserveSubmitVo.getPhoneNumber());
                newMember.setRegTime(LocalDateTime.now()); // 设置注册时间
                // 其他字段如 password, email, birthday 等，如果需要，可以在前端收集或后端生成默认值
                // 这里只设置了预约页面收集的必要信息

                memberService.add(newMember); // 调用会员服务新增会员
                memberId = newMember.getId(); // 获取新会员的ID
                log.info("新会员注册成功，ID: {}", memberId);
            } else {
                // 3. 如果是老会员，使用现有会员ID
                memberId = member.getId();
                log.info("老会员预约，ID: {}", memberId);

                // 可以选择在这里更新会员信息，如果前端提交的姓名、身份证等信息有更新
                // if (!member.getName().equals(reserveSubmitVo.getName())) { ... }
            }

            // 4. 创建预约记录
            Reserve reserve = new Reserve();
            reserve.setMemberId(memberId); // 设置会员ID
            reserve.setOrderDate(reserveSubmitVo.getOrderDate());
            reserve.setSetmealId(reserveSubmitVo.getSetmealId());
            reserve.setOrderType(Reserve.ORDERTYPE_WEIXIN); // 假设这里是微信预约，或根据前端传入的类型确定
            reserve.setOrderStatus(Reserve.ORDERSTATUS_NO); // 默认设置为未到诊

            // 5. 调用预约服务新增预约
            reserveService.add(reserve); // 确保 reserveService.add 能够处理 Reserve 对象

            log.info("预约成功，预约日期: {}，套餐ID: {}，会员ID: {}",
                    reserveSubmitVo.getOrderDate(), reserveSubmitVo.getSetmealId(), memberId);
            return new R(true, MessageConstant.ORDER_SUCCESS);
        } catch (Exception e) {
            log.error("预约失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.ORDER_FAIL);
        }
    }

    /**
     * 根据ID查询预约信息（用于编辑回显）
     * URL: /reserve/findById?id=...
     * @param id 预约ID
     * @return 统一响应结果 (Reserve)
     */
    @GetMapping("/findById")
    public R findById(@RequestParam("id") Integer id) {
        try {
            Reserve reserve = reserveService.findById(id);
            if (reserve != null) {
                log.info("根据ID查询预约成功，ID: {}", id);
                return new R(true, MessageConstant.QUERY_ORDER_SUCCESS, reserve);
            } else {
                log.warn("根据ID查询预约失败，ID: {} 不存在", id);
                return new R(false, MessageConstant.QUERY_ORDER_FAIL);
            }
        } catch (Exception e) {
            log.error("根据ID查询预约失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.QUERY_ORDER_FAIL);
        }
    }

    /**
     * 更新预约信息
     * URL: /reserve/edit
     * @param reserve 预约实体
     * @return 统一响应结果
     */
    @PostMapping("/edit")
    public R edit(@RequestBody Reserve reserve) {
        try {
            reserveService.edit(reserve);
            log.info("更新预约成功: {}", reserve);
            return new R(true, MessageConstant.EDIT_ORDER_SUCCESS);
        } catch (Exception e) {
            log.error("更新预约失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.EDIT_ORDER_FAIL);
        }
    }

    /**
     * 根据ID删除预约
     * URL: /reserve/delete?id=...
     * @param id 预约ID
     * @return 统一响应结果
     */
    @DeleteMapping("/delete")
    public R delete(@RequestParam("id") Integer id) {
        try {
            reserveService.deleteById(id);
            log.info("删除预约成功，ID: {}", id);
            return new R(true, MessageConstant.DELETE_ORDER_SUCCESS);
        } catch (Exception e) {
            log.error("删除预约失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.DELETE_ORDER_FAIL);
        }
    }

    // 保留原有的 /editReservations 和 /getOrderSettingByMonth，但如果不再使用，可以删除
    // 这些是预约设置相关的接口，而非具体预约记录的CRUD
    /**
     * 批量保存预约设置
     * @param reserveSettings 预约设置列表
     * @return 统一响应结果
     */
    @PostMapping("/editReservations")
    public R editReservations(@RequestBody List<ReserveSetting> reserveSettings) {
        try {
            // 这里需要调用 IReserveSettingService，而不是 IReserveService
            // 根据之前提供的 CheckGroupController.java，这里可能需要一个 IReserveSettingService
            // 假设您已经有或会创建对应的 IReserveSettingService
            // reserveSettingService.editReservations(reserveSettings); // 请替换为您实际的服务调用
            log.warn("editReservations 接口被调用，但实际的 ReserveSettingService 调用未实现。");
            return new R(true, MessageConstant.EDIT_ORDERSETTING_SUCCESS);
        } catch (Exception e) {
            log.error("保存预约设置失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.EDIT_ORDERSETTING_FAIL);
        }
    }

    /**
     * 根据月份获取预约设置数据
     * @param date 年月字符串 (YYYY-MM)
     * @return 统一响应结果 (List<ReserveSetting>)
     */
    @GetMapping("/getOrderSettingByMonth")
    public R getOrderSettingByMonth(@RequestParam("date") String date) {
        try {
            // 这里也需要调用 IReserveSettingService
            // List<ReserveSetting> orderSettings = reserveSettingService.listReserveSettingByMonth(date); // 请替换为您实际的服务调用
            List<ReserveSetting> orderSettings = new ArrayList<>(); // 临时返回空列表
            log.warn("getOrderSettingByMonth 接口被调用，但实际的 ReserveSettingService 调用未实现。");
            return new R(true, MessageConstant.GET_ORDERSETTING_SUCCESS, orderSettings);
        } catch (Exception e) {
            log.error("获取预约设置失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.GET_ORDERSETTING_FAIL);
        }
    }
}